import pytest
from openai.lib.streaming.chat._completions import ChatCompletionStreamState

# --- Minimal stubs for types and helpers to allow tests to run standalone ---

class DummyParsedChatCompletion:
    def __init__(self, id, choices):
        self.id = id
        self.choices = choices

    def to_dict(self):
        return {"id": self.id, "choices": [c.to_dict() for c in self.choices]}

class DummyParsedChoice:
    def __init__(self, message, finish_reason="stop"):
        self.message = message
        self.finish_reason = finish_reason

    def to_dict(self):
        return {"message": self.message.to_dict(), "finish_reason": self.finish_reason}

class DummyParsedMessage:
    def __init__(self, content, tool_calls=None, refusal=False):
        self.content = content
        self.tool_calls = tool_calls or []
        self.refusal = refusal

    def to_dict(self):
        return {
            "content": self.content,
            "tool_calls": [tc.to_dict() for tc in self.tool_calls] if self.tool_calls else None,
            "refusal": self.refusal,
        }

class DummyToolCall:
    def __init__(self, type, id="tool1", function=None, custom=None):
        self.type = type
        self.id = id
        self.function = function
        self.custom = custom

    def to_dict(self):
        out = {"type": self.type, "id": self.id}
        if self.type == "function":
            out["function"] = self.function
        if self.type == "custom":
            out["custom"] = self.custom
        return out

class DummyFunction:
    def __init__(self, name, arguments):
        self.name = name
        self.arguments = arguments

class DummyCustom:
    def __init__(self, name):
        self.name = name

# --- Exception stubs ---

class LengthFinishReasonError(Exception):
    pass

class ContentFilterFinishReasonError(Exception):
    pass

# --- The function under test, simplified for standalone testing ---
def get_final_completion(state):
    """
    Simulates the behavior of ChatCompletionStreamState.get_final_completion().
    Expects `state` to have a .current_completion_snapshot attribute,
    which is a DummyParsedChatCompletion.
    """
    # Simulate raising for length/content_filter finish_reason
    for choice in state.current_completion_snapshot.choices:
        if getattr(choice, "finish_reason", None) == "length":
            raise LengthFinishReasonError()
        if getattr(choice, "finish_reason", None) == "content_filter":
            raise ContentFilterFinishReasonError()
    # Simulate parsing tool_calls and content
    # (for this test, just return the snapshot as is)
    return state.current_completion_snapshot

# --- Helper for state simulation ---
class DummyState:
    def __init__(self, snapshot):
        self.current_completion_snapshot = snapshot

# --- Unit Tests ---

# 1. Basic Test Cases













#------------------------------------------------
import pytest
from openai.lib.streaming.chat._completions import ChatCompletionStreamState

# --- Function to test: get_final_completion ---
# Since the actual implementation is not provided, we create a minimal but correct
# implementation based on the docstring and context above. For testing purposes,
# we will simulate a simple version and mock the required classes and behaviors.

# --- Minimal stubs for required classes and helpers ---

class ParsedChatCompletion:
    def __init__(self, data):
        self.data = data
from openai.lib.streaming.chat._completions import ChatCompletionStreamState

# --- Pytest unit tests ---

# 1. Basic Test Cases






def test_no_snapshots():
    """Test when no snapshots are provided at all."""
    state = ChatCompletionStreamState()
    codeflash_output = state.get_final_completion(); result = codeflash_output